home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / disk / diskFragIO.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-31  |  4.5 KB  |  145 lines
  1. /* 
  2.  * fragIO.c --
  3.  *
  4.  *    Routines to allow fragments to be read and written.
  5.  *
  6.  * Copyright (C) 1986 Regents of the University of California
  7.  * All rights reserved.
  8.  */
  9.  
  10. #ifndef lint
  11. static char rcsid[] = "$Header: /sprite/src/lib/disk/RCS/diskFragIO.c,v 1.6 91/09/14 15:17:11 mendel Exp $ SPRITE (Berkeley)";
  12. #endif not lint
  13.  
  14. #include <disk.h>
  15. #include <stdio.h>
  16.  
  17. #define    SECTORS_PER_FRAG       (FS_FRAGMENT_SIZE / DEV_BYTES_PER_SECTOR)
  18.  
  19.  
  20. /*
  21.  *----------------------------------------------------------------------
  22.  *
  23.  * Disk_FragRead --
  24.  *    Read fragments from the disk file at a specified 1K block offset.
  25.  *    This has to use the disk geometry information to figure out
  26.  *    what disk sectors correspond to the block.
  27.  *
  28.  * Results:
  29.  *    0 if could read the disk, -1 if could not.  If couldn't read the disk
  30.  *    then the error is stored in errno.
  31.  *
  32.  * Side effects:
  33.  *    None.
  34.  *
  35.  *----------------------------------------------------------------------
  36.  */
  37. int
  38. Disk_FragRead(openFileID, headerPtr, firstFrag, numFrags, buffer)
  39.     int         openFileID; /* Handle on raw disk */
  40.     Ofs_DomainHeader     *headerPtr; /* Domain header with geometry 
  41.                      * information. */
  42.     int         firstFrag;  /* First frag to read */
  43.     int         numFrags;   /* The number of fragments to read */
  44.     Address         buffer;        /* The buffer to read into */
  45. {
  46.     register Ofs_Geometry    *geoPtr;
  47.     register int    cylinder;
  48.     register int    rotationalSet;
  49.     register int    blockNumber;
  50.     int            sector;
  51.  
  52.     geoPtr = &headerPtr->geometry;
  53.  
  54.     blockNumber        = firstFrag / FS_FRAGMENTS_PER_BLOCK;
  55.     cylinder        = blockNumber / geoPtr->blocksPerCylinder;
  56.     if (geoPtr->rotSetsPerCyl > 0) {
  57.     /*
  58.      * Original mapping scheme using rotational sets.
  59.      */
  60.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  61.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  62.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  63.     
  64.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  65.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  66.          rotationalSet + geoPtr->blockOffset[blockNumber];
  67.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  68.     } else if (geoPtr->rotSetsPerCyl == OFS_SCSI_MAPPING){
  69.     /*
  70.      * New mapping for scsi devices.
  71.      */
  72.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  73.             firstFrag * SECTORS_PER_FRAG - cylinder * 
  74.             geoPtr->blocksPerCylinder * DISK_SECTORS_PER_BLOCK;
  75.     } else {
  76.     return -1;
  77.     }
  78.     return(Disk_SectorRead(openFileID, sector, 
  79.         numFrags * SECTORS_PER_FRAG, buffer));
  80. }
  81.  
  82.  
  83. /*
  84.  *----------------------------------------------------------------------
  85.  *
  86.  * Disk_FragWrite --
  87.  *    Write fragments to the disk file at a specified 1K block offset.
  88.  *    This has to use the disk geometry information to figure out
  89.  *    what disk sectors correspond to the block.
  90.  *
  91.  * Results:
  92.  *    0 if could write the disk, -1 if could not.  If couldn't write the
  93.  *    disk then the error is stored in errno.
  94.  *
  95.  * Side effects:
  96.  *    None.
  97.  *
  98.  *----------------------------------------------------------------------
  99.  */
  100. int
  101. Disk_FragWrite(openFileID, headerPtr, firstFrag, numFrags, buffer)
  102.     int         openFileID; /* Handle on raw disk */
  103.     Ofs_DomainHeader     *headerPtr; /* Domain header with geometry 
  104.                        information. */
  105.     int         firstFrag;  /* First frag to write */
  106.     int         numFrags;   /* The number of fragments to write */
  107.     Address         buffer;        /* The buffer to write out of. */
  108. {
  109.     register Ofs_Geometry *geoPtr;
  110.     register int cylinder;
  111.     register int rotationalSet;
  112.     register int blockNumber;
  113.     int      sector;
  114.  
  115.     geoPtr = &headerPtr->geometry;
  116.  
  117.     blockNumber        = firstFrag / FS_FRAGMENTS_PER_BLOCK;
  118.     cylinder        = blockNumber / geoPtr->blocksPerCylinder;
  119.     if (geoPtr->rotSetsPerCyl > 0) {
  120.     /*
  121.      * Original mapping scheme using rotational sets.
  122.      */
  123.     blockNumber        -= cylinder * geoPtr->blocksPerCylinder;
  124.     rotationalSet    = blockNumber / geoPtr->blocksPerRotSet;
  125.     blockNumber        -= rotationalSet * geoPtr->blocksPerRotSet;
  126.     
  127.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  128.          geoPtr->sectorsPerTrack * geoPtr->tracksPerRotSet *
  129.          rotationalSet + geoPtr->blockOffset[blockNumber];
  130.     sector += (firstFrag % FS_FRAGMENTS_PER_BLOCK) * SECTORS_PER_FRAG;
  131.     } else if (geoPtr->rotSetsPerCyl == OFS_SCSI_MAPPING){
  132.     /*
  133.      * New mapping for scsi devices.
  134.      */
  135.     sector = geoPtr->sectorsPerTrack * geoPtr->numHeads * cylinder +
  136.             firstFrag * SECTORS_PER_FRAG - cylinder * 
  137.             geoPtr->blocksPerCylinder * DISK_SECTORS_PER_BLOCK;
  138.     } else {
  139.     return -1;
  140.     }
  141.  
  142.      return(Disk_SectorWrite(openFileID, sector,
  143.         numFrags * SECTORS_PER_FRAG, buffer));
  144. }
  145.